home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / swingall.jar / javax / swing / text / DefaultStyledDocument$ElementBuffer.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-07-15  |  12.6 KB  |  744 lines
  1. package javax.swing.text;
  2.  
  3. import java.io.Serializable;
  4. import java.util.Stack;
  5. import java.util.Vector;
  6.  
  7. public class DefaultStyledDocument$ElementBuffer implements Serializable {
  8.    // $FF: synthetic field
  9.    private final DefaultStyledDocument this$0;
  10.    Element root;
  11.    transient int pos;
  12.    transient int offset;
  13.    transient int length;
  14.    transient int endOffset;
  15.    transient Vector changes;
  16.    transient Stack path;
  17.    transient boolean insertOp;
  18.    transient boolean recreateLeafs;
  19.    transient DefaultStyledDocument.ElementBuffer.ElemChanges[] insertPath;
  20.    transient boolean createdFracture;
  21.    transient Element fracturedParent;
  22.    transient Element fracturedChild;
  23.    transient boolean offsetLastIndex;
  24.    transient boolean offsetLastIndexOnReplace;
  25.  
  26.    public DefaultStyledDocument$ElementBuffer(DefaultStyledDocument var1, Element var2) {
  27.       this.this$0 = var1;
  28.       this.root = var2;
  29.       this.changes = new Vector();
  30.       this.path = new Stack();
  31.    }
  32.  
  33.    void advance(int var1) {
  34.       this.pos += var1;
  35.    }
  36.  
  37.    void beginEdits(int var1, int var2) {
  38.       this.offset = var1;
  39.       this.length = var2;
  40.       this.endOffset = var1 + var2;
  41.       this.pos = var1;
  42.       if (this.changes == null) {
  43.          this.changes = new Vector();
  44.       } else {
  45.          this.changes.removeAllElements();
  46.       }
  47.  
  48.       if (this.path == null) {
  49.          this.path = new Stack();
  50.       } else {
  51.          this.path.removeAllElements();
  52.       }
  53.  
  54.       this.fracturedParent = null;
  55.       this.fracturedChild = null;
  56.       this.offsetLastIndex = this.offsetLastIndexOnReplace = false;
  57.    }
  58.  
  59.    boolean canJoin(Element var1, Element var2) {
  60.       if (var1 != null && var2 != null) {
  61.          if (var1.isLeaf() != var2.isLeaf()) {
  62.             return false;
  63.          } else {
  64.             return var1.getName().equals("paragraph") && var2.getName().equals("paragraph") ? true : var1.getAttributes().isEqual(var2.getAttributes());
  65.          }
  66.       } else {
  67.          return false;
  68.       }
  69.    }
  70.  
  71.    public void change(int var1, int var2, AbstractDocument.DefaultDocumentEvent var3) {
  72.       this.beginEdits(var1, var2);
  73.       this.changeUpdate();
  74.       this.endEdits(var3);
  75.    }
  76.  
  77.    protected void changeUpdate() {
  78.       boolean var1 = this.split(this.offset, this.length);
  79.       if (!var1) {
  80.          while(this.path.size() != 0) {
  81.             this.pop();
  82.          }
  83.  
  84.          this.split(this.offset + this.length, 0);
  85.       }
  86.  
  87.       while(this.path.size() != 0) {
  88.          this.pop();
  89.       }
  90.  
  91.    }
  92.  
  93.    public Element clone(Element var1, Element var2) {
  94.       if (var2.isLeaf()) {
  95.          return this.this$0.createLeafElement(var1, var2.getAttributes(), var2.getStartOffset(), var2.getEndOffset());
  96.       } else {
  97.          Element var3 = this.this$0.createBranchElement(var1, var2.getAttributes());
  98.          int var4 = var2.getElementCount();
  99.          Element[] var5 = new Element[var4];
  100.  
  101.          for(int var6 = 0; var6 < var4; ++var6) {
  102.             var5[var6] = this.clone(var3, var2.getElement(var6));
  103.          }
  104.  
  105.          ((AbstractDocument.BranchElement)var3).replace(0, 0, var5);
  106.          return var3;
  107.       }
  108.    }
  109.  
  110.    void create(int var1, DefaultStyledDocument.ElementSpec[] var2, AbstractDocument.DefaultDocumentEvent var3) {
  111.       this.insertOp = true;
  112.       this.beginEdits(this.offset, var1);
  113.       Element var4 = this.root;
  114.  
  115.       Element var6;
  116.       for(int var5 = var4.getElementIndex(0); !var4.isLeaf(); var5 = var6.getElementIndex(0)) {
  117.          var6 = var4.getElement(var5);
  118.          this.push(var4, var5);
  119.          var4 = var6;
  120.       }
  121.  
  122.       DefaultStyledDocument.ElementBuffer.ElemChanges var10 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  123.       Element var7 = var10.parent.getElement(var10.index);
  124.       var10.added.addElement(this.this$0.createLeafElement(var10.parent, var7.getAttributes(), this.this$0.getLength(), var7.getEndOffset()));
  125.       var10.removed.addElement(var7);
  126.  
  127.       while(this.path.size() > 1) {
  128.          this.pop();
  129.       }
  130.  
  131.       int var8 = var2.length;
  132.  
  133.       for(int var9 = 1; var9 < var8; ++var9) {
  134.          this.insertElement(var2[var9]);
  135.       }
  136.  
  137.       while(this.path.size() != 0) {
  138.          this.pop();
  139.       }
  140.  
  141.       this.endEdits(var3);
  142.       this.insertOp = false;
  143.    }
  144.  
  145.    void endEdits(AbstractDocument.DefaultDocumentEvent var1) {
  146.       int var2 = this.changes.size();
  147.  
  148.       for(int var3 = 0; var3 < var2; ++var3) {
  149.          DefaultStyledDocument.ElementBuffer.ElemChanges var4 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.changes.elementAt(var3);
  150.          Element[] var5 = new Element[var4.removed.size()];
  151.          var4.removed.copyInto(var5);
  152.          Element[] var6 = new Element[var4.added.size()];
  153.          var4.added.copyInto(var6);
  154.          int var7 = var4.index;
  155.          ((AbstractDocument.BranchElement)var4.parent).replace(var7, var5.length, var6);
  156.          AbstractDocument.ElementEdit var8 = new AbstractDocument.ElementEdit((AbstractDocument.BranchElement)var4.parent, var7, var5, var6);
  157.          var1.addEdit(var8);
  158.       }
  159.  
  160.    }
  161.  
  162.    void fracture(int var1) {
  163.       int var2 = this.insertPath.length;
  164.       int var3 = -1;
  165.       boolean var4 = this.recreateLeafs;
  166.       DefaultStyledDocument.ElementBuffer.ElemChanges var5 = this.insertPath[var2 - 1];
  167.       boolean var6 = var5.index + 1 < var5.parent.getElementCount();
  168.       int var7 = var4 ? var2 : -1;
  169.       int var8 = var2 - 1;
  170.       this.createdFracture = true;
  171.  
  172.       for(int var9 = var2 - 2; var9 >= 0; --var9) {
  173.          DefaultStyledDocument.ElementBuffer.ElemChanges var10 = this.insertPath[var9];
  174.          if (var10.added.size() > 0 || var9 == var1) {
  175.             var3 = var9;
  176.             if (!var4 && var6) {
  177.                var4 = true;
  178.                if (var7 == -1) {
  179.                   var7 = var8 + 1;
  180.                }
  181.             }
  182.          }
  183.  
  184.          if (!var6 && var10.index < var10.parent.getElementCount()) {
  185.             var6 = true;
  186.             var8 = var9;
  187.          }
  188.       }
  189.  
  190.       if (var4) {
  191.          if (var3 == -1) {
  192.             var3 = var2 - 1;
  193.          }
  194.  
  195.          this.fractureFrom(this.insertPath, var3, var7);
  196.       }
  197.  
  198.    }
  199.  
  200.    void fractureDeepestLeaf(DefaultStyledDocument.ElementSpec[] var1) {
  201.       DefaultStyledDocument.ElementBuffer.ElemChanges var2 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  202.       Element var3 = var2.parent.getElement(var2.index);
  203.       if (this.offset != 0) {
  204.          Element var4 = this.this$0.createLeafElement(var2.parent, var3.getAttributes(), var3.getStartOffset(), this.offset);
  205.          var2.added.addElement(var4);
  206.       }
  207.  
  208.       var2.removed.addElement(var3);
  209.       if (var3.getEndOffset() != this.endOffset) {
  210.          this.recreateLeafs = true;
  211.       } else {
  212.          this.offsetLastIndex = true;
  213.       }
  214.  
  215.    }
  216.  
  217.    void fractureFrom(DefaultStyledDocument.ElementBuffer.ElemChanges[] var1, int var2, int var3) {
  218.       DefaultStyledDocument.ElementBuffer.ElemChanges var4 = var1[var2];
  219.       int var7 = var1.length;
  220.       Element var5;
  221.       if (var2 + 1 == var7) {
  222.          var5 = var4.parent.getElement(var4.index);
  223.       } else {
  224.          var5 = var4.parent.getElement(var4.index - 1);
  225.       }
  226.  
  227.       Element var6;
  228.       if (var5.isLeaf()) {
  229.          var6 = this.this$0.createLeafElement(var4.parent, var5.getAttributes(), Math.max(this.endOffset, var5.getStartOffset()), var5.getEndOffset());
  230.       } else {
  231.          var6 = this.this$0.createBranchElement(var4.parent, var5.getAttributes());
  232.       }
  233.  
  234.       this.fracturedParent = var4.parent;
  235.       this.fracturedChild = var6;
  236.       Element var8 = var6;
  237.  
  238.       while(true) {
  239.          ++var2;
  240.          if (var2 >= var3) {
  241.             return;
  242.          }
  243.  
  244.          boolean var9 = var2 + 1 == var3;
  245.          boolean var10 = var2 + 1 == var7;
  246.          var4 = var1[var2];
  247.          if (var9) {
  248.             if (!this.offsetLastIndex && var10) {
  249.                var5 = var4.parent.getElement(var4.index);
  250.             } else {
  251.                var5 = null;
  252.             }
  253.          } else {
  254.             var5 = var4.parent.getElement(var4.index - 1);
  255.          }
  256.  
  257.          if (var5 != null) {
  258.             if (var5.isLeaf()) {
  259.                var6 = this.this$0.createLeafElement(var8, var5.getAttributes(), Math.max(this.endOffset, var5.getStartOffset()), var5.getEndOffset());
  260.             } else {
  261.                var6 = this.this$0.createBranchElement(var8, var5.getAttributes());
  262.             }
  263.          } else {
  264.             var6 = null;
  265.          }
  266.  
  267.          int var11 = var4.parent.getElementCount() - var4.index;
  268.          byte var14 = 1;
  269.          Element[] var12;
  270.          int var13;
  271.          if (var6 == null) {
  272.             if (var10) {
  273.                --var11;
  274.                var13 = var4.index + 1;
  275.             } else {
  276.                var13 = var4.index;
  277.             }
  278.  
  279.             var14 = 0;
  280.             var12 = new Element[var11];
  281.          } else {
  282.             if (!var9) {
  283.                ++var11;
  284.                var13 = var4.index;
  285.             } else {
  286.                var13 = var4.index + 1;
  287.             }
  288.  
  289.             var12 = new Element[var11];
  290.             var12[0] = var6;
  291.          }
  292.  
  293.          for(int var15 = var14; var15 < var11; ++var15) {
  294.             Element var16 = var4.parent.getElement(var13++);
  295.             var12[var15] = this.recreateFracturedElement(var8, var16);
  296.             var4.removed.addElement(var16);
  297.          }
  298.  
  299.          ((AbstractDocument.BranchElement)var8).replace(0, 0, var12);
  300.          var8 = var6;
  301.       }
  302.    }
  303.  
  304.    public Element getRootElement() {
  305.       return this.root;
  306.    }
  307.  
  308.    public void insert(int var1, int var2, DefaultStyledDocument.ElementSpec[] var3, AbstractDocument.DefaultDocumentEvent var4) {
  309.       this.insertOp = true;
  310.       this.beginEdits(var1, var2);
  311.       this.insertUpdate(var3);
  312.       this.endEdits(var4);
  313.       this.insertOp = false;
  314.    }
  315.  
  316.    void insertElement(DefaultStyledDocument.ElementSpec var1) {
  317.       DefaultStyledDocument.ElementBuffer.ElemChanges var2 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  318.       switch (var1.getType()) {
  319.          case 1:
  320.             switch (var1.getDirection()) {
  321.                case 5:
  322.                   Element var6 = var2.parent.getElement(var2.index);
  323.                   if (var6.isLeaf()) {
  324.                      if (var2.index + 1 >= var2.parent.getElementCount()) {
  325.                         throw new StateInvariantError("Join next to leaf");
  326.                      }
  327.  
  328.                      var6 = var2.parent.getElement(var2.index + 1);
  329.                   }
  330.  
  331.                   this.push(var6, 0, true);
  332.                   return;
  333.                case 6:
  334.                default:
  335.                   Element var9 = this.this$0.createBranchElement(var2.parent, var1.getAttributes());
  336.                   var2.added.addElement(var9);
  337.                   this.push(var9, 0);
  338.                   return;
  339.                case 7:
  340.                   if (!this.createdFracture) {
  341.                      this.fracture(this.path.size() - 1);
  342.                   }
  343.  
  344.                   if (!var2.isFracture) {
  345.                      this.push(this.fracturedChild, 0, true);
  346.                   } else {
  347.                      this.push(var2.parent.getElement(0), 0, true);
  348.                   }
  349.  
  350.                   return;
  351.             }
  352.          case 2:
  353.             this.pop();
  354.             break;
  355.          case 3:
  356.             int var3 = var1.getLength();
  357.             if (var1.getDirection() != 5) {
  358.                Element var8 = this.this$0.createLeafElement(var2.parent, var1.getAttributes(), this.pos, this.pos + var3);
  359.                var2.added.addElement(var8);
  360.             } else if (var2.isFracture) {
  361.                Element var7 = var2.parent.getElement(0);
  362.                Element var11 = this.this$0.createLeafElement(var2.parent, var7.getAttributes(), this.pos, var7.getEndOffset());
  363.                var2.added.addElement(var11);
  364.                var2.removed.addElement(var7);
  365.             } else {
  366.                Element var4 = null;
  367.                if (this.insertPath != null) {
  368.                   for(int var5 = this.insertPath.length - 1; var5 >= 0; --var5) {
  369.                      if (this.insertPath[var5] == var2) {
  370.                         if (var5 != this.insertPath.length - 1) {
  371.                            var4 = var2.parent.getElement(var2.index);
  372.                         }
  373.                         break;
  374.                      }
  375.                   }
  376.                }
  377.  
  378.                if (var4 == null) {
  379.                   var4 = var2.parent.getElement(var2.index + 1);
  380.                }
  381.  
  382.                Element var10 = this.this$0.createLeafElement(var2.parent, var4.getAttributes(), this.pos, var4.getEndOffset());
  383.                var2.added.addElement(var10);
  384.                var2.removed.addElement(var4);
  385.             }
  386.  
  387.             this.pos += var3;
  388.       }
  389.  
  390.    }
  391.  
  392.    void insertFirstContent(DefaultStyledDocument.ElementSpec[] var1) {
  393.       DefaultStyledDocument.ElementSpec var2 = var1[0];
  394.       DefaultStyledDocument.ElementBuffer.ElemChanges var3 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  395.       Element var4 = var3.parent.getElement(var3.index);
  396.       int var5 = this.offset + var2.getLength();
  397.       boolean var6 = var1.length == 1;
  398.       switch (var2.getDirection()) {
  399.          case 4:
  400.             if (var4.getEndOffset() != var5 && !var6) {
  401.                Element var10 = this.this$0.createLeafElement(var3.parent, var4.getAttributes(), var4.getStartOffset(), var5);
  402.                var3.added.addElement(var10);
  403.                var3.removed.addElement(var4);
  404.                if (var4.getEndOffset() != this.endOffset) {
  405.                   this.recreateLeafs = true;
  406.                } else {
  407.                   this.offsetLastIndex = true;
  408.                }
  409.             } else {
  410.                this.offsetLastIndex = true;
  411.                this.offsetLastIndexOnReplace = true;
  412.             }
  413.             break;
  414.          case 5:
  415.             if (this.offset != 0) {
  416.                Element var7 = this.this$0.createLeafElement(var3.parent, var4.getAttributes(), var4.getStartOffset(), this.offset);
  417.                var3.added.addElement(var7);
  418.                Element var8 = var3.parent.getElement(var3.index + 1);
  419.                if (var6) {
  420.                   var7 = this.this$0.createLeafElement(var3.parent, var8.getAttributes(), this.offset, var8.getEndOffset());
  421.                } else {
  422.                   var7 = this.this$0.createLeafElement(var3.parent, var8.getAttributes(), this.offset, var5);
  423.                }
  424.  
  425.                var3.added.addElement(var7);
  426.                var3.removed.addElement(var4);
  427.                var3.removed.addElement(var8);
  428.             }
  429.             break;
  430.          default:
  431.             if (var4.getStartOffset() != this.offset) {
  432.                Element var11 = this.this$0.createLeafElement(var3.parent, var4.getAttributes(), var4.getStartOffset(), this.offset);
  433.                var3.added.addElement(var11);
  434.             }
  435.  
  436.             var3.removed.addElement(var4);
  437.             Element var12 = this.this$0.createLeafElement(var3.parent, var2.getAttributes(), this.offset, var5);
  438.             var3.added.addElement(var12);
  439.             if (var4.getEndOffset() != this.endOffset) {
  440.                this.recreateLeafs = true;
  441.             } else {
  442.                this.offsetLastIndex = true;
  443.             }
  444.       }
  445.  
  446.    }
  447.  
  448.    protected void insertUpdate(DefaultStyledDocument.ElementSpec[] var1) {
  449.       Element var2 = this.root;
  450.  
  451.       Element var4;
  452.       for(int var3 = var2.getElementIndex(this.offset); !var2.isLeaf(); var3 = var4.getElementIndex(this.offset)) {
  453.          var4 = var2.getElement(var3);
  454.          this.push(var2, var4.isLeaf() ? var3 : var3 + 1);
  455.          var2 = var4;
  456.       }
  457.  
  458.       this.insertPath = new DefaultStyledDocument.ElementBuffer.ElemChanges[this.path.size()];
  459.       this.path.copyInto(this.insertPath);
  460.       this.createdFracture = false;
  461.       this.recreateLeafs = false;
  462.       int var9;
  463.       if (var1[0].getType() == 3) {
  464.          this.insertFirstContent(var1);
  465.          this.pos += var1[0].getLength();
  466.          var9 = 1;
  467.       } else {
  468.          this.fractureDeepestLeaf(var1);
  469.          var9 = 0;
  470.       }
  471.  
  472.       for(int var5 = var1.length; var9 < var5; ++var9) {
  473.          this.insertElement(var1[var9]);
  474.       }
  475.  
  476.       if (!this.createdFracture) {
  477.          this.fracture(-1);
  478.       }
  479.  
  480.       while(this.path.size() != 0) {
  481.          this.pop();
  482.       }
  483.  
  484.       if (this.offsetLastIndex && this.offsetLastIndexOnReplace) {
  485.          ++this.insertPath[this.insertPath.length - 1].index;
  486.       }
  487.  
  488.       for(int var6 = this.insertPath.length - 1; var6 >= 0; --var6) {
  489.          DefaultStyledDocument.ElementBuffer.ElemChanges var7 = this.insertPath[var6];
  490.          if (var7.parent == this.fracturedParent) {
  491.             var7.added.addElement(this.fracturedChild);
  492.          }
  493.  
  494.          if ((var7.added.size() > 0 || var7.removed.size() > 0) && !this.changes.contains(var7)) {
  495.             this.changes.addElement(var7);
  496.          }
  497.       }
  498.  
  499.       if (this.offset == 0 && this.fracturedParent != null && var1[0].getType() == 2) {
  500.          int var10;
  501.          for(var10 = 0; var10 < var1.length && var1[var10].getType() == 2; ++var10) {
  502.          }
  503.  
  504.          DefaultStyledDocument.ElementBuffer.ElemChanges var8 = this.insertPath[this.insertPath.length - var10 - 1];
  505.          var8.removed.insertElementAt(var8.parent.getElement(--var8.index), 0);
  506.       }
  507.  
  508.    }
  509.  
  510.    Element join(Element var1, Element var2, Element var3, int var4, int var5) {
  511.       if (var2.isLeaf() && var3.isLeaf()) {
  512.          return this.this$0.createLeafElement(var1, var2.getAttributes(), var2.getStartOffset(), var3.getEndOffset());
  513.       } else if (!var2.isLeaf() && !var3.isLeaf()) {
  514.          Element var6 = this.this$0.createBranchElement(var1, var2.getAttributes());
  515.          int var7 = var2.getElementIndex(var4);
  516.          int var8 = var3.getElementIndex(var5);
  517.          Element var9 = var2.getElement(var7);
  518.          if (var9.getStartOffset() == var4) {
  519.             var9 = null;
  520.          }
  521.  
  522.          Element var10 = var3.getElement(var8);
  523.          if (var10.getStartOffset() == var5) {
  524.             var10 = null;
  525.          }
  526.  
  527.          Vector var11 = new Vector();
  528.  
  529.          for(int var12 = 0; var12 < var7; ++var12) {
  530.             var11.addElement(this.clone(var6, var2.getElement(var12)));
  531.          }
  532.  
  533.          if (this.canJoin(var9, var10)) {
  534.             Element var13 = this.join(var6, var9, var10, var4, var5);
  535.             var11.addElement(var13);
  536.          } else {
  537.             if (var9 != null) {
  538.                var11.addElement(this.clone(var6, var9));
  539.             }
  540.  
  541.             if (var10 != null) {
  542.                var11.addElement(this.clone(var6, var10));
  543.             }
  544.          }
  545.  
  546.          int var16 = var3.getElementCount();
  547.  
  548.          for(int var14 = var10 == null ? var8 : var8 + 1; var14 < var16; ++var14) {
  549.             var11.addElement(this.clone(var6, var3.getElement(var14)));
  550.          }
  551.  
  552.          Element[] var15 = new Element[var11.size()];
  553.          var11.copyInto(var15);
  554.          ((AbstractDocument.BranchElement)var6).replace(0, 0, var15);
  555.          return var6;
  556.       } else {
  557.          throw new StateInvariantError("No support to join leaf element with non-leaf element");
  558.       }
  559.    }
  560.  
  561.    void pop() {
  562.       DefaultStyledDocument.ElementBuffer.ElemChanges var1 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  563.       this.path.pop();
  564.       if (var1.added.size() <= 0 && var1.removed.size() <= 0) {
  565.          if (!this.path.isEmpty()) {
  566.             Element var2 = var1.parent;
  567.             if (var2.getElementCount() == 0) {
  568.                var1 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  569.                var1.added.removeElement(var2);
  570.             }
  571.          }
  572.       } else {
  573.          this.changes.addElement(var1);
  574.       }
  575.  
  576.    }
  577.  
  578.    void push(Element var1, int var2) {
  579.       this.push(var1, var2, false);
  580.    }
  581.  
  582.    void push(Element var1, int var2, boolean var3) {
  583.       DefaultStyledDocument.ElementBuffer.ElemChanges var4 = new DefaultStyledDocument.ElementBuffer.ElemChanges(this, var1, var2, var3);
  584.       this.path.push(var4);
  585.    }
  586.  
  587.    Element recreateFracturedElement(Element var1, Element var2) {
  588.       if (var2.isLeaf()) {
  589.          return this.this$0.createLeafElement(var1, var2.getAttributes(), Math.max(var2.getStartOffset(), this.endOffset), var2.getEndOffset());
  590.       } else {
  591.          Element var3 = this.this$0.createBranchElement(var1, var2.getAttributes());
  592.          int var4 = var2.getElementCount();
  593.          Element[] var5 = new Element[var4];
  594.  
  595.          for(int var6 = 0; var6 < var4; ++var6) {
  596.             var5[var6] = this.recreateFracturedElement(var3, var2.getElement(var6));
  597.          }
  598.  
  599.          ((AbstractDocument.BranchElement)var3).replace(0, 0, var5);
  600.          return var3;
  601.       }
  602.    }
  603.  
  604.    public void remove(int var1, int var2, AbstractDocument.DefaultDocumentEvent var3) {
  605.       this.beginEdits(var1, var2);
  606.       this.removeUpdate();
  607.       this.endEdits(var3);
  608.    }
  609.  
  610.    boolean removeElements(Element var1, int var2, int var3) {
  611.       if (!var1.isLeaf()) {
  612.          int var4 = var1.getElementIndex(var2);
  613.          int var5 = var1.getElementIndex(var3);
  614.          this.push(var1, var4);
  615.          DefaultStyledDocument.ElementBuffer.ElemChanges var6 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  616.          if (var4 == var5) {
  617.             Element var13 = var1.getElement(var4);
  618.             if (var2 <= var13.getStartOffset() && var3 >= var13.getEndOffset()) {
  619.                var6.removed.addElement(var13);
  620.             } else if (this.removeElements(var13, var2, var3)) {
  621.                var6.removed.addElement(var13);
  622.             }
  623.          } else {
  624.             Element var7 = var1.getElement(var4);
  625.             Element var8 = var1.getElement(var5);
  626.             boolean var9 = var3 < var1.getEndOffset();
  627.             if (var9 && this.canJoin(var7, var8)) {
  628.                for(int var14 = var4; var14 <= var5; ++var14) {
  629.                   var6.removed.addElement(var1.getElement(var14));
  630.                }
  631.  
  632.                Element var15 = this.join(var1, var7, var8, var2, var3);
  633.                var6.added.addElement(var15);
  634.             } else {
  635.                int var10 = var4 + 1;
  636.                int var11 = var5 - 1;
  637.                if (var7.getStartOffset() == var2 || var4 == 0 && var7.getStartOffset() > var2 && var7.getEndOffset() <= var3) {
  638.                   var7 = null;
  639.                   var10 = var4;
  640.                }
  641.  
  642.                if (!var9) {
  643.                   var8 = null;
  644.                   ++var11;
  645.                } else if (var8.getStartOffset() == var3) {
  646.                   var8 = null;
  647.                }
  648.  
  649.                if (var10 <= var11) {
  650.                   var6.index = var10;
  651.                }
  652.  
  653.                for(int var12 = var10; var12 <= var11; ++var12) {
  654.                   var6.removed.addElement(var1.getElement(var12));
  655.                }
  656.  
  657.                if (var7 != null && this.removeElements(var7, var2, var3)) {
  658.                   var6.removed.insertElementAt(var7, 0);
  659.                   var6.index = var4;
  660.                }
  661.  
  662.                if (var8 != null && this.removeElements(var8, var2, var3)) {
  663.                   var6.removed.addElement(var8);
  664.                }
  665.             }
  666.          }
  667.  
  668.          this.pop();
  669.          if (var1.getElementCount() == var6.removed.size() - var6.added.size()) {
  670.             return true;
  671.          }
  672.       }
  673.  
  674.       return false;
  675.    }
  676.  
  677.    protected void removeUpdate() {
  678.       this.removeElements(this.root, this.offset, this.offset + this.length);
  679.    }
  680.  
  681.    boolean split(int var1, int var2) {
  682.       boolean var3 = false;
  683.       Element var4 = this.root;
  684.  
  685.       for(int var5 = var4.getElementIndex(var1); !var4.isLeaf(); var5 = var4.getElementIndex(var1)) {
  686.          this.push(var4, var5);
  687.          var4 = var4.getElement(var5);
  688.       }
  689.  
  690.       DefaultStyledDocument.ElementBuffer.ElemChanges var6 = (DefaultStyledDocument.ElementBuffer.ElemChanges)this.path.peek();
  691.       Element var7 = var6.parent.getElement(var6.index);
  692.       if (var7.getStartOffset() != var1) {
  693.          int var8 = var6.index;
  694.          int var9 = var8;
  695.          if (var1 + var2 < var6.parent.getEndOffset() && var2 != 0) {
  696.             var9 = var6.parent.getElementIndex(var1 + var2);
  697.             if (var9 == var8) {
  698.                var6.removed.addElement(var7);
  699.                var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), var7.getStartOffset(), var1);
  700.                var6.added.addElement(var4);
  701.                var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), var1, var1 + var2);
  702.                var6.added.addElement(var4);
  703.                var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), var1 + var2, var7.getEndOffset());
  704.                var6.added.addElement(var4);
  705.                return true;
  706.             }
  707.  
  708.             var7 = var6.parent.getElement(var9);
  709.             if (var1 + var2 == var7.getStartOffset()) {
  710.                var9 = var8;
  711.             }
  712.  
  713.             var3 = true;
  714.          }
  715.  
  716.          this.pos = var1;
  717.          var7 = var6.parent.getElement(var8);
  718.          var6.removed.addElement(var7);
  719.          var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), var7.getStartOffset(), this.pos);
  720.          var6.added.addElement(var4);
  721.          var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), this.pos, var7.getEndOffset());
  722.          var6.added.addElement(var4);
  723.  
  724.          for(int var10 = var8 + 1; var10 < var9; ++var10) {
  725.             var7 = var6.parent.getElement(var10);
  726.             var6.removed.addElement(var7);
  727.             var6.added.addElement(var7);
  728.          }
  729.  
  730.          if (var9 != var8) {
  731.             var7 = var6.parent.getElement(var9);
  732.             this.pos = var1 + var2;
  733.             var6.removed.addElement(var7);
  734.             var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), var7.getStartOffset(), this.pos);
  735.             var6.added.addElement(var4);
  736.             var4 = this.this$0.createLeafElement(var6.parent, var7.getAttributes(), this.pos, var7.getEndOffset());
  737.             var6.added.addElement(var4);
  738.          }
  739.       }
  740.  
  741.       return var3;
  742.    }
  743. }
  744.